import { ITypeEntityField } from '@/types/modules/superType/types';

/**
 * 采样配置
 */
interface SampleConfig {
  /** 最大采样数量 */
  maxSamples?: number;
  /** 最小覆盖率（用于判断required） */
  requiredThreshold?: number;
  /** 最大递归深度 */
  maxDepth?: number;
}

/**
 * 字段统计信息
 */
interface FieldStats {
  /** 字段名 */
  name: string;
  /** 出现次数 */
  count: number;
  /** 总样本数 */
  total: number;
  /** 观察到的类型集合 */
  types: Set<string>;
  /** 是否为数组 */
  isArray: boolean;
  /** 示例值 */
  examples: any[];
  /** 子字段统计（对象类型） */
  childStats?: Map<string, FieldStats>;
}

/**
 * 智能采样：从JSON数据生成ITypeEntityField[]
 * 解决简单采样的问题：字段遗漏、required判断不准确
 */
export const jsonToFields = (data: any, config: SampleConfig = {}): ITypeEntityField[] => {
  const {
    maxSamples = 100,
    requiredThreshold = 0.8, // 80%以上出现率视为required
    maxDepth = 10,
  } = config;

  // 处理JSON字符串情况
  let parsedData = data;
  if (typeof data === 'string') {
    try {
      parsedData = JSON.parse(data);
    } catch (e) {
      console.error('JSON解析失败:', e);
      return [];
    }
  }

  /**
   * 分析对象数组，统计每个字段在所有对象中的出现情况
   */
  const analyzeObjectArray = (array: any[], depth: number = 0): Map<string, FieldStats> => {
    if (depth >= maxDepth || !Array.isArray(array) || array.length === 0) {
      return new Map();
    }

    const samples = array.slice(0, maxSamples);
    const stats = new Map<string, FieldStats>();
    const totalSamples = samples.length;

    // 遍历每个对象样本
    samples.forEach((item, index) => {
      if (typeof item === 'object' && item !== null) {
        // 分析当前对象的每个字段
        Object.keys(item).forEach((fieldName) => {
          const fieldValue = item[fieldName];
          const isArray = Array.isArray(fieldValue);
          let fieldType = isArray
            ? fieldValue.length > 0
              ? typeof fieldValue[0]
              : 'object'
            : typeof fieldValue;

          // 特殊处理：如果是日期字符串，标记为 string
          if (
            typeof fieldValue === 'string' &&
            /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(fieldValue)
          ) {
            fieldType = 'string';
          }

          // 初始化字段统计
          if (!stats.has(fieldName)) {
            stats.set(fieldName, {
              name: fieldName,
              count: 0,
              total: totalSamples,
              types: new Set(),
              isArray: false,
              examples: [],
              childStats: new Map(),
            });
          }

          const fieldStat = stats.get(fieldName)!;

          // 更新统计信息
          fieldStat.count += 1;
          fieldStat.types.add(fieldType);
          fieldStat.isArray = fieldStat.isArray || isArray;

          // 收集示例值（最多保留3个）
          if (fieldStat.examples.length < 3) {
            fieldStat.examples.push(fieldValue);
          }

          // 递归分析子结构
          if (isArray && fieldValue.length > 0) {
            // 处理数组字段
            const childStats = analyzeObjectArray(fieldValue, depth + 1);
            mergeChildStats(fieldStat.childStats!, childStats);
          } else if (typeof fieldValue === 'object' && fieldValue !== null) {
            // 处理对象字段
            const childStats = analyzeSingleObject(fieldValue, depth + 1);
            mergeChildStats(fieldStat.childStats!, childStats);
          }
        });
      }
    });

    return stats;
  };

  /**
   * 分析单个对象
   */
  const analyzeSingleObject = (
    obj: Record<string, any>,
    depth: number = 0,
  ): Map<string, FieldStats> => {
    if (depth >= maxDepth || typeof obj !== 'object' || obj === null) {
      return new Map();
    }

    const stats = new Map<string, FieldStats>();

    Object.keys(obj).forEach((fieldName) => {
      const fieldValue = obj[fieldName];
      const isArray = Array.isArray(fieldValue);
      const fieldType = isArray
        ? fieldValue.length > 0
          ? typeof fieldValue[0]
          : 'object'
        : typeof fieldValue;

      stats.set(fieldName, {
        name: fieldName,
        count: 1,
        total: 1,
        types: new Set([fieldType]),
        isArray,
        examples: [fieldValue],
        childStats: new Map(),
      });

      const fieldStat = stats.get(fieldName)!;

      // 递归分析子结构
      if (isArray && fieldValue.length > 0) {
        fieldStat.childStats = analyzeObjectArray(fieldValue, depth + 1);
      } else if (typeof fieldValue === 'object' && fieldValue !== null) {
        fieldStat.childStats = analyzeSingleObject(fieldValue, depth + 1);
      }
    });

    return stats;
  };

  /**
   * 合并子字段统计
   */
  const mergeChildStats = (target: Map<string, FieldStats>, source: Map<string, FieldStats>) => {
    source.forEach((sourceStat, fieldName) => {
      if (!target.has(fieldName)) {
        target.set(fieldName, { ...sourceStat });
      } else {
        const targetStat = target.get(fieldName)!;
        targetStat.count += sourceStat.count;
        targetStat.total = Math.max(targetStat.total, sourceStat.total);
        sourceStat.types.forEach((type) => targetStat.types.add(type));
        targetStat.isArray = targetStat.isArray || sourceStat.isArray;

        // 合并示例值
        if (targetStat.examples.length < 3) {
          targetStat.examples.push(...sourceStat.examples.slice(0, 3 - targetStat.examples.length));
        }

        // 递归合并子字段
        if (sourceStat.childStats) {
          mergeChildStats(targetStat.childStats!, sourceStat.childStats);
        }
      }
    });
  };

  /**
   * 将统计信息转换为字段定义
   */
  const statsToFields = (statsMap: Map<string, FieldStats>): ITypeEntityField[] => {
    const result = Array.from(statsMap.values()).map((stat) => {
      // 判断字段类型
      const typeArray = Array.from(stat.types);
      const primaryType =
        typeArray.length === 1 ? typeArray[0] : typeArray.includes('object') ? 'object' : 'string';

      // 判断是否required（出现率超过阈值）
      const required = stat.count / stat.total >= requiredThreshold;

      // 生成示例值
      const example = stat.examples.length > 0 ? stat.examples[0] : undefined;

      const field: ITypeEntityField = {
        name: stat.name,
        type: primaryType as any,
        required,
        isArray: stat.isArray,
        desc: undefined, // 不需要统计信息
        example: typeof example !== 'object' ? example : undefined,
      };

      // 递归处理子字段
      if (stat.childStats && stat.childStats.size > 0) {
        field.fields = statsToFields(stat.childStats);
      }

      return field;
    });

    return result;
  };

  // 根据数据类型选择分析策略
  let structure: Map<string, FieldStats>;

  if (Array.isArray(parsedData)) {
    // 顶层是数组：分析数组中对象的字段分布
    structure = analyzeObjectArray(parsedData);
  } else if (typeof parsedData === 'object' && parsedData !== null) {
    // 顶层是对象：直接分析对象字段
    structure = analyzeSingleObject(parsedData);
  } else {
    // 其他类型：返回空
    structure = new Map();
  }

  return statsToFields(structure);
};

/**
 * 判断字段是否需要自动生成
 * 当字段有default值且用户未手动修改fields时触发
 */
export const shouldAutoGenerateFields = (field: ITypeEntityField): boolean => {
  return !!(
    field.type === 'object' &&
    field.default &&
    (!field.fields || field.fields.length === 0)
  );
};

/**
 * 更新字段定义：保持用户手动修改的fields，自动生成未定义的
 */
export const mergeGeneratedFields = (
  originalFields: ITypeEntityField[] = [],
  generatedFields: ITypeEntityField[],
): ITypeEntityField[] => {
  const result = [...originalFields];

  generatedFields.forEach((generated) => {
    const existing = result.find((f) => f.name === generated.name);

    if (existing) {
      // 如果用户没有手动定义子字段，则使用生成的
      if (shouldAutoGenerateFields(existing)) {
        existing.fields = generated.fields;
        existing.desc = generated.desc; // 更新统计信息
      }
    } else {
      // 新字段直接添加
      result.push(generated);
    }
  });

  return result;
};

/**
 * 生成TypeScript接口字符串（供AI理解）
 */
export const fieldsToTypeScript = (
  fields: ITypeEntityField[],
  interfaceName: string = 'DataType',
): string => {
  const generateFieldType = (field: ITypeEntityField, indent = '  '): string => {
    let typeStr = field.type || 'any';

    // 处理对象类型
    if (field.type === 'object' && field.fields?.length) {
      const childFields = field.fields.map((f) => generateFieldType(f, indent + '  ')).join('\n');
      typeStr = `{\n${childFields}\n${indent}}`;
    }

    // 处理数组类型
    if (field.isArray) {
      typeStr += '[]';
    }

    // 处理可选字段
    const optional = !field.required ? '?' : '';

    return `${indent}${field.name}${optional}: ${typeStr};`;
  };

  const fieldStrings = fields.map((f) => generateFieldType(f)).join('\n');

  return `interface ${interfaceName} {\n${fieldStrings}\n}`;
};
